package com.agileboot.common.core.command;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
import lombok.Getter;

/**
 * 批量操作命令类
 * 用于处理批量删除、批量更新等操作
 *
 * @author valarchie
 */
@Getter
public class BulkOperationCommand<T> {

    /**
     * 操作项列表
     */
    private final List<T> items;
    
    /**
     * 操作前预检查函数
     */
    private final Predicate<T> preCheck;
    
    /**
     * 操作结果
     */
    private final List<OperationResult<T>> results = new ArrayList<>();
    
    /**
     * 成功记录数
     */
    private int successCount = 0;
    
    /**
     * 失败记录数
     */
    private int failureCount = 0;

    /**
     * 构造函数
     *
     * @param items 操作项数组
     */
    public BulkOperationCommand(T[] items) {
        this(items, null);
    }

    /**
     * 构造函数
     *
     * @param items 操作项列表
     */
    public BulkOperationCommand(List<T> items) {
        this(items, null);
    }

    /**
     * 构造函数
     *
     * @param items 操作项数组
     * @param preCheck 操作前预检查函数
     */
    public BulkOperationCommand(T[] items, Predicate<T> preCheck) {
        this.items = Arrays.asList(items);
        this.preCheck = preCheck;
    }
    
    /**
     * 构造函数
     *
     * @param items 操作项列表
     * @param preCheck 操作前预检查函数
     */
    public BulkOperationCommand(List<T> items, Predicate<T> preCheck) {
        this.items = items;
        this.preCheck = preCheck;
    }
    
    /**
     * 获取操作项列表ID
     * 兼容原有代码
     *
     * @return 操作项列表
     */
    public List<T> getIds() {
        return items;
    }
    
    /**
     * 执行批量操作
     *
     * @param operation 操作函数
     * @return 是否全部成功
     */
    public boolean execute(Function<T, Boolean> operation) {
        for (T item : items) {
            OperationResult<T> result = new OperationResult<>(item);
            
            try {
                // 执行预检查
                if (preCheck != null && !preCheck.test(item)) {
                    result.setSuccess(false);
                    result.setErrorMessage("预检查失败");
                    failureCount++;
                } else {
                    // 执行操作
                    Boolean success = operation.apply(item);
                    result.setSuccess(success != null && success);
                    
                    if (result.isSuccess()) {
                        successCount++;
                    } else {
                        failureCount++;
                        result.setErrorMessage("操作失败");
                    }
                }
            } catch (Exception e) {
                result.setSuccess(false);
                result.setErrorMessage(e.getMessage());
                failureCount++;
            }
            
            results.add(result);
        }
        
        return failureCount == 0;
    }
    
    /**
     * 获取总记录数
     *
     * @return 总记录数
     */
    public int getTotal() {
        return items.size();
    }
    
    /**
     * 操作结果内部类
     *
     * @param <T> 操作项类型
     */
    @Getter
    public static class OperationResult<T> {
        
        /**
         * 操作项
         */
        private final T item;
        
        /**
         * 是否成功
         */
        private boolean success;
        
        /**
         * 错误信息
         */
        private String errorMessage;
        
        /**
         * 构造函数
         *
         * @param item 操作项
         */
        public OperationResult(T item) {
            this.item = item;
            this.success = false;
        }
        
        /**
         * 设置是否成功
         *
         * @param success 是否成功
         */
        public void setSuccess(boolean success) {
            this.success = success;
        }
        
        /**
         * 设置错误信息
         *
         * @param errorMessage 错误信息
         */
        public void setErrorMessage(String errorMessage) {
            this.errorMessage = errorMessage;
        }
    }
} 